package com.zyl.blog.service;/**
 * @author 14323
 * @date 2020/8/11 17:06
 */

import com.zyl.blog.dao.CommentRepository;
import com.zyl.blog.pojo.Comment;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Sort;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * @Description: TODO
 * @author: scott
 * @date: 2020年08月11日 17:06
 */
@Service
public class CommentServiceImpl implements CommentService {

    @Autowired
    private CommentRepository commentRepository;

    @Override
    public List<Comment> listCommentByBlogId(Long blogId) {

        List<Comment> commentList = commentRepository.findByBlogIdAndParentCommentNull(blogId, Sort.by(Sort.Direction.DESC, "createTime"));
        //返回重新组织评论级别关系的评论集合
        return eachComment(commentList);
    }

    /*
    * 循环每个顶级的评论节点
    * */
    private List<Comment> eachComment(List<Comment> commentList) {

        List<Comment> commentsView = new ArrayList<>();

        for (Comment comment : commentList) {
            Comment c = new Comment();
            BeanUtils.copyProperties(comment, c);
            commentsView.add(c);
        }

        //合并评论的各层子评论到第一层评论中，只保留一个父评论，其他所有评论都作为此父评论的子评论
        combineChildren(commentsView);
        //返回用于合并后的评论集
        return commentsView;
    }

    //临时子评论集，存入一个父评论下的所有子评论，即将所有评论转为一个父评论和一个子评论集
    private List<Comment> tempReplys = new ArrayList<>();

    //合并所有子评论到一个子评论集中（tempReplys）
    private void combineChildren(List<Comment> commentsView) {

        for (Comment comment : commentsView) {

            List<Comment> Replys1 = comment.getReplyComments();

            for (Comment Reply1 : Replys1) {
                //循环迭代，找出子级评论，存放在tempReplys中
                recursively(Reply1);
            }
            //修改顶级节点的Reply集合为迭代处理后的集合
            comment.setReplyComments(tempReplys);
            //清除临时存放区
            tempReplys = new ArrayList<>();
        }
    }

    /*
    * 迭代递归，将一个评论下所有子评论及其子评论的子评论都作为该评论的子评论
    * */
    private void recursively(Comment ReplyComment) {

        //将第一层子评论放入临时子评论集中
        tempReplys.add(ReplyComment);

        //若该第一层子评论下还有子评论，则将其全部放入临时子评论集中，以实现中保留一个父评论和一个子评论集
        if (ReplyComment.getReplyComments().size() > 0) {
            //得到第一层子评论下的子评论集
            List<Comment> replys = ReplyComment.getReplyComments();
            //迭代该该子评论集，所有子评论加入临时子评论集中
            for (Comment Reply :replys) {
                //将子评论的子评论放入临时子评论集中
                tempReplys.add(Reply);
                if (Reply.getReplyComments().size() > 0) {
                    recursively(Reply);
                }
            }
        }

    }

    @Override
    public Comment saveComment(Comment comment) {
        Long parentCommentId = comment.getParentComment().getId();
        if (parentCommentId != -1) {
            //如果父级评论的ID不为-1，说明此条评论是回复别人的，那么为此条评论设置父级评论，以建立联系
            comment.setParentComment(commentRepository.findById(parentCommentId).get());
        } else {
            //如果不为-1，说明这是一条新评论，那么就将它的父级评论设为Null
            comment.setParentComment(null);
        }
        comment.setCreateTime(new Date());
        commentRepository.save(comment);
        return null;
    }


}
